home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / C Internet Config / IC Component Source ƒ / IC Resource ƒ / Syslog Component ƒ / syslog.c < prev    next >
Encoding:
Text File  |  1995-11-15  |  9.7 KB  |  281 lines  |  [TEXT/SPM ]
  1. /*
  2.     syslog.c
  3.     
  4.     syslog glue for indirect access to the syslog component.
  5.     
  6. */
  7.  
  8.  
  9. #include <stdarg.h>
  10. #include <string.h>
  11. #include <stdio.h>
  12.  
  13. #include <Components.h>
  14.  
  15. #include "syslog.h"
  16.  
  17. #include "libsprintf.h"
  18.  
  19. ComponentInstance _gSyslogComponent=(ComponentInstance)0;
  20. char* _gSyslogBuf=(char*)0;
  21. void SyslogInit(void);
  22.  
  23. void syslog(short priority,const char* format,...){
  24.     
  25.     // try to open if not already done so
  26.     if (_gSyslogComponent==(ComponentInstance)0)
  27.         SyslogInit();
  28.     
  29.     // still couldn't open, return
  30.     if (_gSyslogComponent==(ComponentInstance)0)
  31.         return;
  32.     
  33.     // expand into buf
  34.     libvsprintf(_gSyslogBuf,format,__va(format));
  35.     
  36.     // expanded, now send to syslog
  37.     Comp_syslog(_gSyslogComponent,priority,_gSyslogBuf);
  38. }
  39.  
  40. void openlog(const char* ident,short logopts,short facility){
  41.     
  42.     // try to open if not already done so
  43.     if (_gSyslogComponent==(ComponentInstance)0)
  44.         SyslogInit();
  45.     
  46.     // still couldn't open, return
  47.     if (_gSyslogComponent==(ComponentInstance)0)
  48.         return;
  49.     
  50.     Comp_openlog(_gSyslogComponent,ident,logopts,facility);
  51. }
  52.  
  53. void closelog(void){
  54.     
  55.     // try to open if not already done so
  56.     if (_gSyslogComponent==(ComponentInstance)0)
  57.         SyslogInit();
  58.     
  59.     // still couldn't open, return
  60.     if (_gSyslogComponent==(ComponentInstance)0)
  61.         return;
  62.     
  63.     Comp_closelog(_gSyslogComponent);
  64. }
  65.  
  66. OSErr syslogerr(void){
  67.     OSErr err;
  68.     
  69.     // try to open if not already done so
  70.     if (_gSyslogComponent==(ComponentInstance)0)
  71.         SyslogInit();
  72.     
  73.     // still couldn't open, return
  74.     if (_gSyslogComponent==(ComponentInstance)0)
  75.         return (OSErr)-1;
  76.     
  77.     Comp_geterror(_gSyslogComponent,&err);
  78.     
  79.     return err;
  80. }
  81.  
  82. OSErr setsyslogfile(FSSpecPtr spec){
  83.     
  84.     // try to open if not already done so
  85.     if (_gSyslogComponent==(ComponentInstance)0)
  86.         SyslogInit();
  87.     
  88.     // still couldn't open, return
  89.     if (_gSyslogComponent==(ComponentInstance)0)
  90.         return;
  91.     
  92.     return (OSErr)Comp_setfile(_gSyslogComponent,spec);
  93. }
  94.  
  95. short setlogmask(short maskpri){
  96.     short oldpri;
  97.     
  98.     // try to open if not already done so
  99.     if (_gSyslogComponent==(ComponentInstance)0)
  100.         SyslogInit();
  101.     
  102.     // still couldn't open, return
  103.     if (_gSyslogComponent==(ComponentInstance)0)
  104.         return 0;
  105.     
  106.     oldpri=Comp_setlogmask(_gSyslogComponent,maskpri);
  107.     
  108.     return oldpri;
  109. }
  110.  
  111. /*
  112.     HaveComponentMgr
  113.     
  114.     Uses Gestalt to check for the availability of the Component Manager.  We assume that if Gestalt
  115.     does not return an error then the Component Manager exists.  If we were concerned with what
  116.     version of the Component Manager that we had we could check the result to see if it is at least
  117.     the version that we need.
  118. */
  119. Boolean HaveComponentMgr(void){
  120.     OSErr err;
  121.     long result;
  122.     
  123.     err=Gestalt(gestaltComponentMgr,&result);
  124.     
  125.     if (err!=noErr)
  126.         return false;
  127.     else
  128.         return true;
  129. }
  130.  
  131. enum {
  132.     uppExitToShellProcInfo=kPascalStackBased
  133. };
  134. #if USESROUTINEDESCRIPTORS
  135. typedef UniversalProcPtr ExitToShellUPP;
  136. #define NewExitToShellProc(routine) \
  137.     (ExitToShellUPP) NewRoutineDescriptor((ProcPtr)(routine), \
  138.         uppExitToShellProcInfo, GetCurrentISA())
  139. #define CallExitToShellProc(routine) \
  140.     CallUniversalProc((UniversalProcPtr)(routine), uppExitToShellProcI align=mac68k
  141.     struct GlueParms {
  142.         OSErr* errp;
  143.     };
  144.     typedef struct GlueParms GlueParms;
  145.     struct ICCallGlue {
  146.         PPC_Glue(GlueParms);
  147.     };
  148.     typedef struct ICCallGlue ICCallGlue;
  149.     #pragma options align=reset
  150.     
  151.     ICCallGlue glue;
  152.     
  153.     if (inst == (ComponentInstance)0) {
  154.         err = badComponentInstance;
  155.     } else {
  156.         SetupGlue(glue,kGetErrorSelector,GlueParms,inst);
  157.         
  158.         SetGlueParm(glue,errp,errp);
  159.         
  160.         err = CallComponentGlue(&glue);
  161.     }
  162.     return err;
  163. }
  164.  
  165. pascal ComponentResult Comp_openlog(ComponentInstance inst,const char* ident,
  166.         long logopt,short facility){
  167.     ComponentResult err;
  168.     
  169.     #pragma options align=mac68k
  170.     struct GlueParms {
  171.         short facility;
  172.         long logopt;
  173.         const char* ident;
  174.     };
  175.     typedef struct GlueParms GlueParms;
  176.     struct ICCallGlue {
  177.         PPC_Glue(GlueParms);
  178.     };
  179.     typedef struct ICCallGlue ICCallGlue;
  180.     #pragma options align=reset
  181.     
  182.     ICCallGlue glue;
  183.     
  184.     if (inst == (ComponentInstance)0) {
  185.         err = badComponentInstance;
  186.     } else {
  187.         SetupGlue(glue,kopenlogSelector,GlueParms,inst);
  188.         
  189.         SetGlueParm(glue,ident,ident);
  190.         SetGlueParm(glue,logopt,logopt);
  191.         SetGlueParm(glue,facility,facility);
  192.         
  193.         err = CallComponentGlue(&glue);
  194.     }
  195.     return err;
  196. }
  197.  
  198. pascal ComponentResult Comp_syslog(ComponentInstance inst,short priority,
  199.         const char* message){
  200.     ComponentResult err;
  201.     
  202.     #pragma options align=mac68k
  203.     struct GlueParms {
  204.         const char* message;
  205.         short priority;
  206.     };
  207.     typedef struct GlueParms GlueParms;
  208.     struct ICCallGlue {
  209.         PPC_Glue(GlueParms);
  210.     };
  211.     typedef struct ICCallGlue ICCallGlue;
  212.     #pragma options align=reset
  213.     
  214.     ICCallGlue glue;
  215.     
  216.     if (inst == (ComponentInstance)0) {
  217.         err = badComponentInstance;
  218.     } else {
  219.         SetupGlue(glue,ksyslogSelector,GlueParms,inst);
  220.         
  221.         SetGlueParm(glue,message,message);
  222.         SetGlueParm(glue,priority,priority);
  223.         
  224.         err = CallComponentGlue(&glue);
  225.     }
  226.     return err;
  227. }
  228.  
  229. pascal ComponentResult Comp_closelog(ComponentInstance inst){
  230.     ComponentResult err;
  231.     
  232.     #pragma options align=mac68k
  233.     struct ICCallGlue {
  234.         PPC_VoidGlue;
  235.     };
  236.     typedef struct ICCallGlue ICCallGlue;
  237.     #pragma options align=reset
  238.     
  239.     ICCallGlue glue;
  240.     
  241.     if (inst == (ComponentInstance)0) {
  242.         err = badComponentInstance;
  243.     } else {
  244.         SetupVoidGlue(glue,kcloselogSelector,inst);
  245.         
  246.         err = CallComponentGlue(&glue);
  247.     }
  248.     return err;
  249. }
  250.  
  251. pascal ComponentResult Comp_setfile(ComponentInstance inst,FSSpecPtr spec){
  252.     ComponentResult err;
  253.     
  254.     #pragma options align=mac68k
  255.     struct GlueParms {
  256.         FSSpecPtr spec;
  257.     };
  258.     typedef struct GlueParms GlueParms;
  259.     struct ICCallGlue {
  260.         PPC_Glue(GlueParms);
  261.     };
  262.     typedef struct ICCallGlue ICCallGlue;
  263.     #pragma options align=reset
  264.     
  265.     ICCallGlue glue;
  266.     
  267.     if (inst == (ComponentInstance)0) {
  268.         err = badComponentInstance;
  269.     } else {
  270.         SetupGlue(glue,kSetFileSelector,GlueParms,inst);
  271.         
  272.         SetGlueParm(glue,spec,spec);
  273.         
  274.         err = CallComponentGlue(&glue);
  275.     }
  276.     return err;
  277. }
  278.  
  279. #endif
  280.  
  281.